/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package dao;

import dao.exceptions.NonexistentEntityException;
import java.io.Serializable;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import ecfdb.Legumes;
import ecfdb.Depot;
import ecfdb.LegumesDepot;
import ecfdb.Vente;
import java.util.ArrayList;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;

/**
 *
 * @author QEMLAB
 */
public class LegumesDepotJpaController implements Serializable {

    public LegumesDepotJpaController(EntityManagerFactory emf) {
        this.emf = emf;
    }
    private EntityManagerFactory emf = null;

    public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

    public void create(LegumesDepot legumesDepot) {
        if (legumesDepot.getVenteList() == null) {
            legumesDepot.setVenteList(new ArrayList<Vente>());
        }
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Legumes legumes = legumesDepot.getLegumes();
            if (legumes != null) {
                legumes = em.getReference(legumes.getClass(), legumes.getIdlegumes());
                legumesDepot.setLegumes(legumes);
            }
            Depot depot = legumesDepot.getDepot();
            if (depot != null) {
                depot = em.getReference(depot.getClass(), depot.getIddepot());
                legumesDepot.setDepot(depot);
            }
            List<Vente> attachedVenteList = new ArrayList<Vente>();
            for (Vente venteListVenteToAttach : legumesDepot.getVenteList()) {
                venteListVenteToAttach = em.getReference(venteListVenteToAttach.getClass(), venteListVenteToAttach.getIdvente());
                attachedVenteList.add(venteListVenteToAttach);
            }
            legumesDepot.setVenteList(attachedVenteList);
            em.persist(legumesDepot);
            if (legumes != null) {
                legumes.getLegumesDepotList().add(legumesDepot);
                legumes = em.merge(legumes);
            }
            if (depot != null) {
                depot.getLegumesDepotList().add(legumesDepot);
                depot = em.merge(depot);
            }
            for (Vente venteListVente : legumesDepot.getVenteList()) {
                LegumesDepot oldDepotOfVenteListVente = venteListVente.getDepot();
                venteListVente.setDepot(legumesDepot);
                venteListVente = em.merge(venteListVente);
                if (oldDepotOfVenteListVente != null) {
                    oldDepotOfVenteListVente.getVenteList().remove(venteListVente);
                    oldDepotOfVenteListVente = em.merge(oldDepotOfVenteListVente);
                }
            }
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void edit(LegumesDepot legumesDepot) throws NonexistentEntityException, Exception {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            LegumesDepot persistentLegumesDepot = em.find(LegumesDepot.class, legumesDepot.getIdlegumesDepot());
            Legumes legumesOld = persistentLegumesDepot.getLegumes();
            Legumes legumesNew = legumesDepot.getLegumes();
            Depot depotOld = persistentLegumesDepot.getDepot();
            Depot depotNew = legumesDepot.getDepot();
            List<Vente> venteListOld = persistentLegumesDepot.getVenteList();
            List<Vente> venteListNew = legumesDepot.getVenteList();
            if (legumesNew != null) {
                legumesNew = em.getReference(legumesNew.getClass(), legumesNew.getIdlegumes());
                legumesDepot.setLegumes(legumesNew);
            }
            if (depotNew != null) {
                depotNew = em.getReference(depotNew.getClass(), depotNew.getIddepot());
                legumesDepot.setDepot(depotNew);
            }
            List<Vente> attachedVenteListNew = new ArrayList<Vente>();
            for (Vente venteListNewVenteToAttach : venteListNew) {
                venteListNewVenteToAttach = em.getReference(venteListNewVenteToAttach.getClass(), venteListNewVenteToAttach.getIdvente());
                attachedVenteListNew.add(venteListNewVenteToAttach);
            }
            venteListNew = attachedVenteListNew;
            legumesDepot.setVenteList(venteListNew);
            legumesDepot = em.merge(legumesDepot);
            if (legumesOld != null && !legumesOld.equals(legumesNew)) {
                legumesOld.getLegumesDepotList().remove(legumesDepot);
                legumesOld = em.merge(legumesOld);
            }
            if (legumesNew != null && !legumesNew.equals(legumesOld)) {
                legumesNew.getLegumesDepotList().add(legumesDepot);
                legumesNew = em.merge(legumesNew);
            }
            if (depotOld != null && !depotOld.equals(depotNew)) {
                depotOld.getLegumesDepotList().remove(legumesDepot);
                depotOld = em.merge(depotOld);
            }
            if (depotNew != null && !depotNew.equals(depotOld)) {
                depotNew.getLegumesDepotList().add(legumesDepot);
                depotNew = em.merge(depotNew);
            }
            for (Vente venteListOldVente : venteListOld) {
                if (!venteListNew.contains(venteListOldVente)) {
                    venteListOldVente.setDepot(null);
                    venteListOldVente = em.merge(venteListOldVente);
                }
            }
            for (Vente venteListNewVente : venteListNew) {
                if (!venteListOld.contains(venteListNewVente)) {
                    LegumesDepot oldDepotOfVenteListNewVente = venteListNewVente.getDepot();
                    venteListNewVente.setDepot(legumesDepot);
                    venteListNewVente = em.merge(venteListNewVente);
                    if (oldDepotOfVenteListNewVente != null && !oldDepotOfVenteListNewVente.equals(legumesDepot)) {
                        oldDepotOfVenteListNewVente.getVenteList().remove(venteListNewVente);
                        oldDepotOfVenteListNewVente = em.merge(oldDepotOfVenteListNewVente);
                    }
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                Integer id = legumesDepot.getIdlegumesDepot();
                if (findLegumesDepot(id) == null) {
                    throw new NonexistentEntityException("The legumesDepot with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void destroy(Integer id) throws NonexistentEntityException {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            LegumesDepot legumesDepot;
            try {
                legumesDepot = em.getReference(LegumesDepot.class, id);
                legumesDepot.getIdlegumesDepot();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("The legumesDepot with id " + id + " no longer exists.", enfe);
            }
            Legumes legumes = legumesDepot.getLegumes();
            if (legumes != null) {
                legumes.getLegumesDepotList().remove(legumesDepot);
                legumes = em.merge(legumes);
            }
            Depot depot = legumesDepot.getDepot();
            if (depot != null) {
                depot.getLegumesDepotList().remove(legumesDepot);
                depot = em.merge(depot);
            }
            List<Vente> venteList = legumesDepot.getVenteList();
            for (Vente venteListVente : venteList) {
                venteListVente.setDepot(null);
                venteListVente = em.merge(venteListVente);
            }
            em.remove(legumesDepot);
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public List<LegumesDepot> findLegumesDepotEntities() {
        return findLegumesDepotEntities(true, -1, -1);
    }

    public List<LegumesDepot> findLegumesDepotEntities(int maxResults, int firstResult) {
        return findLegumesDepotEntities(false, maxResults, firstResult);
    }

    private List<LegumesDepot> findLegumesDepotEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            cq.select(cq.from(LegumesDepot.class));
            Query q = em.createQuery(cq);
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    public LegumesDepot findLegumesDepot(Integer id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(LegumesDepot.class, id);
        } finally {
            em.close();
        }
    }

    public int getLegumesDepotCount() {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            Root<LegumesDepot> rt = cq.from(LegumesDepot.class);
            cq.select(em.getCriteriaBuilder().count(rt));
            Query q = em.createQuery(cq);
            return ((Long) q.getSingleResult()).intValue();
        } finally {
            em.close();
        }
    }
    
}
